use criterion::{criterion_group, criterion_main, Criterion};
use rand::Rng;
use sorted_array::sorted_array::{SortedArray, SortedArrayCompareFunc, SortedArrayEqualFunc};

// 定义相等性判断函数
fn equ_func(a: &i32, b: &i32) -> bool {
    a == b
}

// 定义比较函数
fn cmp_func(a: &i32, b: &i32) -> std::cmp::Ordering {
    a.cmp(b)
}

fn sorted_array_benchmark(c: &mut Criterion) {
    let mut rng = rand::thread_rng();
    let mut array = SortedArray::new(0, equ_func as SortedArrayEqualFunc<i32>, cmp_func as SortedArrayCompareFunc<i32>);

    // 基准测试：插入操作
    c.bench_function("sorted_array_insert", |b| {
        b.iter(|| {
            let value = rng.gen_range(0..1000);
            array.insert(value);
        })
    });

    // 基准测试：查找操作
    c.bench_function("sorted_array_index_of", |b| {
        let value = rng.gen_range(0..1000);
        b.iter(|| {
            array.index_of(&value);
        })
    });

    // 基准测试：移除操作
    c.bench_function("sorted_array_remove", |b| {
        let index = rng.gen_range(0..array.len());
        b.iter(|| {
            array.remove(index);
        })
    });

    // 基准测试：清空操作
    c.bench_function("sorted_array_clear", |b| {
        b.iter(|| {
            array.clear();
        })
    });

    // 基准测试：获取长度操作
    c.bench_function("sorted_array_len", |b| {
        b.iter(|| {
            array.len();
        })
    });

    // 基准测试：获取元素操作
    c.bench_function("sorted_array_get", |b| {
        let index = rng.gen_range(0..array.len());
        b.iter(|| {
            array.get(index);
        })
    });
}

criterion_group!(benches, sorted_array_benchmark);
criterion_main!(benches);